home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Camelot / Camelot 043 (1989-06)(Swedish User Group of Amiga)(SE)(PD)[WB].zip / Camelot 043 (1989-06)(Swedish User Group of Amiga)(SE)(PD)[WB].adf / Glib / amiga-mach.c < prev    next >
C/C++ Source or Header  |  1989-03-16  |  10KB  |  539 lines
  1. /*
  2.  * GLIB - a Generic LIBrarian and editor for synths
  3.  *
  4.  * Machine dependent stuff.
  5.  *
  6.  * Amiga version.
  7.  */
  8.  
  9. #include "glib.h"
  10. #include <stdio.h>
  11. #include <ctype.h>
  12.  
  13. #include <dos.h>
  14. #include <intuition/intuition.h>
  15. #include <exec/types.h>
  16. #include <exec/ports.h>
  17. #include <exec/io.h>
  18. #include <exec/devices.h>
  19. #include <exec/memory.h>
  20. #include <devices/serial.h>
  21.  
  22. #include <proto/exec.h>
  23. #include <proto/intuition.h>
  24.  
  25. struct IntuitionBase *IntuitionBase;
  26. struct GfxBase *GfxBase;
  27. struct Screen *S;
  28. struct Window *W;
  29. struct RastPort *R;
  30.  
  31. int Rows, Cols;
  32.  
  33. #define TOPEDGE 8    /* how much of screen bar to show */
  34. int WindowWidth = 640;
  35. int WindowHeight = 200 - TOPEDGE;
  36.  
  37. /* standard WB colors */
  38. #define BLUE 0
  39. #define WHITE 1
  40. #define BLACK 2
  41. #define ORANGE 3
  42.  
  43.  
  44. hello()
  45. {
  46.     windinit();
  47.     openmidi();
  48. }
  49.  
  50. bye()
  51. {
  52.     closemidi();
  53.     windexit(0);
  54. }
  55.  
  56. int MouseX, MouseY, MouseButtons;
  57. int Mouseok = 0;
  58.  
  59. /* getmouse - get current row and column of mouse */
  60. getmouse(amr,amc)
  61. int *amr;
  62. int *amc;
  63. {
  64.     *amr = MouseY / 8;
  65.     *amc = MouseX / 8;
  66. }
  67.  
  68. /* statmouse - return mouse button state (0=nothing pressed,1=left,2=right) */
  69. statmouse()
  70. {
  71.     nextevent(MOUSEBUTTONS, 0);
  72.     return MouseButtons;
  73. }
  74.  
  75. /* Return when either a console key or mouse button is pressed. */
  76. mouseorkey()
  77. {
  78.     return nextevent(MOUSEBUTTONS | VANILLAKEY, 1);
  79. }
  80.  
  81. flushconsole()
  82. {
  83.     while (nextevent(VANILLAKEY, 0) >= 0) ;
  84. }
  85.  
  86. getconsole()
  87. {
  88.     return nextevent(VANILLAKEY, 1);
  89. }
  90.  
  91. cursor(state)
  92. int state;
  93. {
  94.     int x, y;
  95.     x = R->cp_x;
  96.     y = R->cp_y - R->Font->tf_Baseline;
  97.     SetDrMd(R, COMPLEMENT);
  98.     RectFill(R, x, y, x+8, y+R->Font->tf_YSize-1);
  99.     SetDrMd(R, JAM2);
  100. }
  101.  
  102. nextevent(flags, wait)
  103. long flags;
  104. int wait;
  105. {
  106.     register int class, code;
  107.     register struct IntuiMessage *message;
  108.     int result;
  109.  
  110.     cursor(1);
  111.     ModifyIDCMP(W, CLOSEWINDOW | flags);
  112.     while (1)
  113.     {
  114.         if (wait)
  115.         {
  116.             /* get next event, waiting if none are available */
  117.             while ((message = (struct IntuiMessage *)GetMsg(W->UserPort)) == NULL)
  118.             {
  119.             Wait(1<<W->UserPort->mp_SigBit);
  120.             }
  121.         }
  122.         else
  123.         {
  124.             /* get next event, but return if none are available */
  125.             message = (struct IntuiMessage *)GetMsg(W->UserPort);
  126.             if (message == NULL)
  127.             {
  128.             result = -1;
  129.             break;
  130.             }
  131.         }
  132.         class = message->Class;
  133.         code = message->Code;
  134.         MouseX = message->MouseX;
  135.         MouseY = message->MouseY;
  136.         ReplyMsg((struct Message *)message);
  137.  
  138.         switch (class)
  139.         {
  140.         case VANILLAKEY:
  141.             result = code;
  142.             break;
  143.         case CLOSEWINDOW:
  144.             result = 'q';
  145.             break;
  146.         case MOUSEBUTTONS:
  147.             switch (code)
  148.             {
  149.             case SELECTDOWN:
  150.                 MouseButtons = 1;
  151.                 break;
  152.             case MENUDOWN:
  153.                 MouseButtons = 2;
  154.                 break;
  155.             default:
  156.                 MouseButtons = 0;
  157.                 break;
  158.             }
  159.             result = MOUSE;
  160.             break;
  161.         default:
  162.             continue;
  163.         }
  164.         break;
  165.     }
  166.     cursor(0);
  167.     return result;
  168. }
  169.  
  170. /*------------------------------------------------------------------------
  171.  * MIDI I/O Routines for Amiga.
  172.  *
  173.  * Uses low-level serial I/O for simultaneous reads and writes.
  174.  */
  175.  
  176. struct MsgPort    *MidiInPort, *MidiOutPort;
  177. struct IOExtSer    *MidiIn, *MidiOut;
  178. int    SerOpen = 0;
  179.  
  180. char    MidiInBuf;
  181. int    MidiDataAvail = 0;
  182.  
  183. /*
  184.  * start an asynchronous read request from MIDI IN
  185.  */
  186.  
  187. startmidiread()
  188. {
  189.     MidiIn->IOSer.io_Data = (APTR) &MidiInBuf;
  190.     MidiIn->IOSer.io_Length = 1;
  191.     MidiIn->IOSer.io_Command = CMD_READ;
  192.     MidiIn->IOSer.io_Flags = IOF_QUICK;    /* use quick I/O */
  193.     BeginIO((struct IORequest *) MidiIn);
  194.     /* did I/O complete quickly? */
  195.     if ((MidiIn->IOSer.io_Flags & IOF_QUICK)) {
  196.         /* wow, data's coming in fast! */
  197.         MidiDataAvail = 1;
  198.     } else {
  199.         /* no data this time, it'll arrive later */
  200.         MidiDataAvail = 0;
  201.     }
  202. }
  203.  
  204. /*
  205.  * get a byte from MIDI IN.
  206.  * assumes startmidiread has been previously done.  if statmidi has been
  207.  * checked, this function will not wait.  otherwise, it will wait for
  208.  * a single byte to arrive if none is available.
  209.  */
  210.  
  211. getmidi()
  212. {
  213.     register struct Message    *io;
  214.     int result;
  215.  
  216.     /* return previously-received data, if available */
  217.     if (MidiDataAvail) {
  218.         result = MidiInBuf;
  219.         /* start a new I/O */
  220.         startmidiread();
  221.         return result;
  222.     }
  223.  
  224.     /* read next available byte */
  225.     io = (struct Message *) CheckIO((struct IORequest *) MidiIn);
  226.     if (io == FALSE) {
  227.         /* wait for next byte */
  228.         WaitIO((struct IORequest *) MidiIn);
  229.         io = &MidiIn->IOSer.io_Message;
  230.     }
  231.  
  232.     Remove(&io->mn_Node);
  233.     result = MidiInBuf;
  234.     startmidiread();    /* start I/O for next byte */
  235.     return result;
  236. }
  237.  
  238. /*
  239.  * write a byte to MIDI OUT
  240.  */
  241.  
  242. sendmidi(c)
  243. int c;
  244. {
  245.     char    buf = c;
  246.  
  247.     MidiOut->IOSer.io_Data = (APTR) &buf;
  248.     MidiOut->IOSer.io_Length = 1;
  249.     MidiOut->IOSer.io_Command = CMD_WRITE;
  250.     DoIO((struct IORequest *) MidiOut);    /* synchronous request */
  251. }
  252.  
  253. /*
  254.  * check if any midi data is waiting to be received
  255.  */
  256. statmidi()
  257. {
  258.     /* check if data has previously been received */
  259.     if (MidiDataAvail) return 1;
  260.  
  261.     /* check if i/o has completed */
  262.     return (CheckIO((struct IORequest *) MidiIn) == FALSE) ? 0 : 1;
  263. }
  264.  
  265. openmidi()
  266. {
  267.     /* create message port for serial device */
  268.     MidiInPort = (struct MsgPort *) CreatePort(SERIALNAME,0);
  269.     if (MidiInPort == NULL) fatal("Can't create MidiInPort");
  270.  
  271.     /* create i/o request block for serial device */
  272.     MidiIn = (struct IOExtSer *)
  273.         CreateExtIO(MidiInPort, sizeof(struct IOExtSer));
  274.     if (MidiIn == NULL) fatal("Can't create MidiIn");
  275.  
  276.     /* open the serial device */
  277.     MidiIn->io_SerFlags = SERF_SHARED;
  278.     SerOpen = OpenDevice(SERIALNAME,0,(struct IORequest *) MidiIn,0) == 0 ? 1 : 0;
  279.     if (SerOpen == 0) fatal("Can't open serial.device");
  280.  
  281.     /* set serial device parameters */
  282.     MidiIn->io_Baud = 31250;
  283.     MidiIn->io_RBufLen = 8192;    /* large input buffer - if your synth
  284.                      * sends dumps larger than this you
  285.                      * will have to increase it. */
  286.     MidiIn->io_SerFlags = SERF_RAD_BOOGIE;
  287.     MidiIn->IOSer.io_Command = SDCMD_SETPARAMS;
  288.     DoIO((struct IORequest *) MidiIn);
  289.  
  290.     /* clone MidiIn into MidiOut to allow simultaneous i/o */
  291.     MidiOutPort = (struct MsgPort *) CreatePort("MidiOut",0);
  292.     if (MidiOutPort == NULL) fatal("Can't create MidiOutPort");
  293.  
  294.     MidiOut = (struct IOExtSer *)
  295.             CreateExtIO(MidiOutPort, sizeof(struct IOExtSer));
  296.     *MidiOut = *MidiIn;
  297.     MidiOut->IOSer.io_Message.mn_ReplyPort = MidiOutPort;
  298.  
  299.     /* get the MIDI IN port started */
  300.     startmidiread();
  301. }
  302.  
  303. closemidi()
  304. {
  305.     if (SerOpen) CloseDevice((struct IORequest *)MidiIn);
  306.     if (MidiIn) DeleteExtIO((struct IORequest *)MidiIn);
  307.     if (MidiOut) DeleteExtIO((struct IORequest *)MidiOut);
  308.     if (MidiInPort) DeletePort(MidiInPort);
  309.     if (MidiOutPort) DeletePort(MidiOutPort);
  310. }
  311.  
  312. flushmidi()
  313. {
  314.     while ( STATMIDI )
  315.         getmidi();
  316. }
  317.  
  318. long milliclock()
  319. {
  320.     unsigned int clock[2];
  321.     long milli;
  322.     timer(clock);
  323.     milli = clock[0] * 1000 + clock[1] / 1000;
  324.     return milli;
  325. }
  326.  
  327. millisleep(n)
  328. {
  329.     Delay(n/20);
  330. }
  331.  
  332. char *
  333. alloc(n)
  334. {
  335.     char *p;
  336.  
  337.     if ( (p=malloc((unsigned)n)) == (char *)NULL ) {
  338.         fatal("GLIB is out of memory!");
  339.     }
  340.     return(p);
  341. }
  342.  
  343. struct TextAttr font =
  344. {
  345.     "topaz.font",TOPAZ_EIGHTY,FS_NORMAL,FPF_ROMFONT
  346. };
  347.  
  348. struct NewScreen ns =
  349. {
  350.     0,0,640,200,2,BLACK,WHITE,HIRES,CUSTOMSCREEN,&font,"",NULL,NULL
  351. };
  352.  
  353. windinit()
  354. {
  355.     struct NewWindow nw;
  356.  
  357.     if (S != NULL) return;
  358.  
  359.     IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library", 0);
  360.     GfxBase = (struct GfxBase *) OpenLibrary("graphics.library",0);
  361.     if (IntuitionBase == NULL || GfxBase == NULL) exit(1);
  362.  
  363.     if ((S = (struct Screen *) OpenScreen(&ns)) == NULL) exit(1);
  364.  
  365.     nw.LeftEdge = 0;
  366.     nw.TopEdge = TOPEDGE;
  367.     nw.Width = WindowWidth;
  368.     nw.Height = WindowHeight;
  369.     nw.DetailPen = BLACK;
  370.     nw.BlockPen = WHITE;
  371.     nw.Title = NULL;
  372.     nw.Flags = SMART_REFRESH | ACTIVATE | BACKDROP |
  373.            BORDERLESS | NOCAREREFRESH | RMBTRAP;
  374.     nw.IDCMPFlags = CLOSEWINDOW | VANILLAKEY;
  375.     nw.Type = CUSTOMSCREEN;
  376.     nw.FirstGadget = NULL;
  377.     nw.CheckMark = NULL;
  378.     nw.Screen = S;
  379.     nw.BitMap = NULL;
  380.     if ((W = (struct Window *) OpenWindow(&nw)) == NULL) exit(1);
  381.     R = W->RPort;
  382.     SetAPen(R, ORANGE);
  383.     SetBPen(R, BLACK);
  384.     ShowTitle(S, FALSE);
  385.     Cols=80;
  386.     Rows=24;
  387. }
  388.  
  389. windgoto(r,c)
  390. int r,c;
  391. {
  392.     Move(R, c*8, r*8 + R->Font->tf_Baseline);
  393. }
  394.  
  395. windeeol()
  396. {
  397.     int x, y;
  398.     x = R->cp_x;
  399.     y = R->cp_y  - R->Font->tf_Baseline;
  400.     SetAPen(R, BLACK);
  401.     RectFill(R, x, y, WindowWidth, y+R->Font->tf_YSize-1);
  402.     SetAPen(R, ORANGE);
  403. }
  404.  
  405. winderaserow(r)
  406. {
  407.     windgoto(r,0);
  408.     windeeol();
  409. }
  410.  
  411. windexit(r)
  412. int r;
  413. {
  414.     if (W) CloseWindow(W);
  415.     if (S) CloseScreen(S);
  416.     exit(r);
  417. }
  418.  
  419. windclear()
  420. {
  421.     SetAPen(R, BLACK);
  422.     RectFill(R, 0, 0, WindowWidth, WindowHeight);
  423.     SetAPen(R, ORANGE);
  424. }
  425.  
  426. /* windgets - get a line of input from the console, handling backspaces */
  427. windgets(s)
  428. char *s;
  429. {
  430.     char *origs = s;
  431.     int c;
  432.  
  433.     SetAPen(R, WHITE);
  434.     while ( (c=getconsole()) != '\n' && c!='\r' && c!= EOF ) {
  435.         if ( c == '\b' ) {
  436.             if ( s > origs ) {
  437.                 wbackspace();
  438.                 s--;
  439.             }
  440.         }
  441.         else if (c == 24) {
  442.             while (s > origs) {
  443.                 wbackspace();
  444.                 s--;
  445.             }
  446.         } else if (isprint(c)) {
  447.             windputc(c);
  448.             *s++ = c;
  449.         }
  450.         windrefresh();
  451.     }
  452.     *s = '\0';
  453.     SetAPen(R, ORANGE);
  454. }
  455.  
  456. windstr(s)
  457. char *s;
  458. {
  459.     Text(R, s, strlen(s));
  460. }
  461.  
  462. windputc(c)
  463. int c;
  464. {
  465.     char s = c;
  466.     Text(R, &s, 1);
  467. }
  468.  
  469. wbackspace()
  470. {
  471.     int x, y;
  472.     x = R->cp_x;
  473.     y = R->cp_y;
  474.     Move(R, x-8, y);
  475.     windputc(' ');
  476.     Move(R, x-8, y);
  477. }
  478.  
  479. windrefresh()
  480. {
  481. }
  482.  
  483. beep()
  484. {
  485.     DisplayBeep(S);
  486. }
  487.  
  488. windhigh()
  489. {
  490. }
  491.  
  492. windnorm()
  493. {
  494. }
  495.  
  496. struct IntuiText fataltext = { 1,0,COMPLEMENT,16,32,NULL,NULL,NULL };
  497. struct IntuiText canceltext = { 1,0,COMPLEMENT,2,2,NULL,"cancel",NULL };
  498.  
  499. fatal(text)
  500. char *text;
  501. {
  502.     fataltext.IText = text;
  503.     AutoRequest(W, &fataltext, NULL, &canceltext, 0, 0, 320, 90);
  504.     bye();
  505. }
  506.  
  507. /****************
  508.  * openls(), nextls(), and closels() are used to scan the current directory.
  509.  ***************/
  510.  
  511. struct FileInfoBlock *lsinfo = NULL;
  512.  
  513. openls()
  514. {
  515. }
  516.  
  517. char *
  518. nextls()
  519. {
  520.     int error;
  521.     if (lsinfo == NULL) {
  522.         lsinfo = (struct FileInfoBlock *) alloc(sizeof(struct FileInfoBlock));
  523.         error = dfind(lsinfo, "#?", 0);
  524.     } else {
  525.         error = dnext(lsinfo);
  526.     }
  527.     if (error == 0) {
  528.         return lsinfo->fib_FileName;
  529.     } else {
  530.         return NULL;
  531.     }
  532. }
  533.  
  534. closels()
  535. {
  536.     free(lsinfo);
  537.     lsinfo = NULL;
  538. }
  539.